package com.docmgmt.mvp.controller;

import com.docmgmt.mvp.dto.AddGroupMembersRequest;
import com.docmgmt.mvp.dto.CreateUserGroupRequest;
import com.docmgmt.mvp.dto.Result;
import com.docmgmt.mvp.dto.UserGroupVO;
import com.docmgmt.mvp.exception.UnauthorizedException;
import com.docmgmt.mvp.service.UserGroupService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 用户组管理 REST API（USER-006）
 *
 * @author Dora
 */
@Slf4j
@RestController
@RequestMapping("/api/v1/user-groups")
@RequiredArgsConstructor
@Tag(name = "用户组管理", description = "用户组创建、成员管理、权限控制（USER-006）")
public class UserGroupController {

    private final UserGroupService userGroupService;

    /**
     * 获取当前登录用户ID
     */
    private Long getCurrentUserId() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            throw new UnauthorizedException("未登录或认证已过期");
        }

        Object principal = authentication.getPrincipal();
        if (principal instanceof Long) {
            return (Long) principal;
        }

        throw new UnauthorizedException("无效的认证信息");
    }

    /**
     * 创建用户组
     * - 创建人自动成为owner
     * - 可选添加初始成员（role默认为member）
     */
    @PostMapping
    @Operation(
            summary = "创建用户组",
            description = "创建新用户组，创建人自动成为owner，可添加初始成员"
    )
    public Result<UserGroupVO> createGroup(
            @Valid @RequestBody CreateUserGroupRequest request) {
        Long creatorId = getCurrentUserId();
        log.info("创建用户组：name={}, creatorId={}", request.getName(), creatorId);

        UserGroupVO group = userGroupService.createGroup(request, creatorId);
        return Result.success("用户组创建成功", group);
    }

    /**
     * 查询当前用户的用户组列表
     * - 返回用户作为成员的所有组
     * - 包含用户在每个组中的角色（myRole字段）
     */
    @GetMapping
    @Operation(
            summary = "查询用户组列表",
            description = "查询当前用户作为成员的所有用户组，包含角色信息"
    )
    public Result<List<UserGroupVO>> listUserGroups() {
        Long userId = getCurrentUserId();
        log.debug("查询用户组列表：userId={}", userId);

        List<UserGroupVO> groups = userGroupService.listUserGroups(userId);
        return Result.success("查询成功", groups);
    }

    /**
     * 查询用户组详情
     * - 需要是组成员才能查询
     * - 返回组信息和当前用户的角色
     */
    @GetMapping("/{groupId}")
    @Operation(
            summary = "查询用户组详情",
            description = "查询指定用户组的详细信息（需要是成员）"
    )
    public Result<UserGroupVO> getGroupDetail(
            @Parameter(description = "用户组ID", required = true)
            @PathVariable Long groupId) {
        Long userId = getCurrentUserId();
        log.debug("查询用户组详情：groupId={}, userId={}", groupId, userId);

        // 从列表中筛选（确保用户是成员）
        List<UserGroupVO> groups = userGroupService.listUserGroups(userId);
        UserGroupVO group = groups.stream()
                .filter(g -> g.getId().equals(groupId))
                .findFirst()
                .orElse(null);

        if (group == null) {
            return Result.error("404", "用户组不存在或您不是成员");
        }

        return Result.success("查询成功", group);
    }

    /**
     * 添加成员到用户组（批量）
     * - 仅owner和admin可操作
     * - 支持批量添加多个用户
     * - 可指定新成员的角色（默认member）
     */
    @PostMapping("/{groupId}/members")
    @Operation(
            summary = "添加成员到用户组",
            description = "批量添加用户到用户组（仅owner/admin可操作）"
    )
    public Result<Void> addMembers(
            @Parameter(description = "用户组ID", required = true)
            @PathVariable Long groupId,
            @Valid @RequestBody AddGroupMembersRequest request) {
        Long operatorId = getCurrentUserId();
        log.info("添加成员到用户组：groupId={}, userIds={}, operatorId={}",
                groupId, request.getUserIds(), operatorId);

        userGroupService.addMembers(groupId, request, operatorId);
        return Result.success("成员添加成功");
    }

    /**
     * 移除用户组成员
     * - owner/admin可移除其他成员
     * - 成员可以移除自己（退出组）
     * - owner不能被移除
     */
    @DeleteMapping("/{groupId}/members/{userId}")
    @Operation(
            summary = "移除用户组成员",
            description = "移除指定成员（owner/admin可移除他人，成员可移除自己）"
    )
    public Result<Void> removeMember(
            @Parameter(description = "用户组ID", required = true)
            @PathVariable Long groupId,
            @Parameter(description = "要移除的用户ID", required = true)
            @PathVariable Long userId) {
        Long operatorId = getCurrentUserId();
        log.info("移除用户组成员：groupId={}, userId={}, operatorId={}", groupId, userId, operatorId);

        userGroupService.removeMember(groupId, userId, operatorId);
        return Result.success("成员移除成功");
    }

    /**
     * 删除用户组
     * - 仅owner可操作
     * - 会级联删除所有成员记录
     */
    @DeleteMapping("/{groupId}")
    @Operation(
            summary = "删除用户组",
            description = "删除用户组及所有成员记录（仅owner可操作）"
    )
    public Result<Void> deleteGroup(
            @Parameter(description = "用户组ID", required = true)
            @PathVariable Long groupId) {
        Long operatorId = getCurrentUserId();
        log.info("删除用户组：groupId={}, operatorId={}", groupId, operatorId);

        userGroupService.deleteGroup(groupId, operatorId);
        return Result.success("用户组删除成功");
    }
}
